package com.warom.sdg.util;

import android.content.Context;
import android.os.Environment;
import android.util.Log;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;

/**
 * 日志工具类，用于记录用户操作到SD卡
 */
public class LogUtils {
    private static final String TAG = "SDGLog";
    private static final String LOG_FOLDER = "sdg_panel_logs";
    private static final String LOG_FILE_PREFIX = "operation_log_";
    private static final SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd", Locale.CHINA);
    private static final SimpleDateFormat TIME_FORMAT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS", Locale.CHINA);
    
    private static String sLogDirPath = null;
    private static boolean sEnabled = true;
    
    /**
     * 初始化日志工具
     * @param context 应用上下文
     */
    public static void init(Context context) {
        // 获取外部存储根目录
        try {
            if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
                File sdcardDir = Environment.getExternalStorageDirectory();
                sLogDirPath = sdcardDir.getAbsolutePath();
                createLogFolder();
                Log.i(TAG, "日志工具初始化成功，日志路径: " + getLogFolderPath());
            } else {
                Log.e(TAG, "外部存储不可用");
                // 备用方案：使用应用专属存储
                File externalFilesDir = context.getExternalFilesDir(null);
                if (externalFilesDir != null) {
                    sLogDirPath = externalFilesDir.getAbsolutePath();
                    createLogFolder();
                    Log.i(TAG, "使用备用存储路径: " + getLogFolderPath());
                } else {
                    Log.e(TAG, "无法获取存储目录");
                }
            }
        } catch (Exception e) {
            Log.e(TAG, "日志工具初始化失败", e);
        }
    }
    
    /**
     * 启用或禁用日志记录
     * @param enabled 是否启用
     */
    public static void setEnabled(boolean enabled) {
        sEnabled = enabled;
        Log.i(TAG, "日志记录" + (enabled ? "已启用" : "已禁用"));
    }
    
    /**
     * 创建日志文件夹
     */
    private static void createLogFolder() {
        File folder = new File(getLogFolderPath());
        if (!folder.exists()) {
            boolean created = folder.mkdirs();
            if (!created) {
                Log.e(TAG, "创建日志文件夹失败: " + folder.getAbsolutePath());
            }
        }
    }
    
    /**
     * 获取日志文件夹路径
     */
    private static String getLogFolderPath() {
        return sLogDirPath + File.separator + LOG_FOLDER;
    }
    
    /**
     * 获取当前日期的日志文件
     */
    private static File getLogFile() {
        String today = DATE_FORMAT.format(new Date());
        String fileName = LOG_FILE_PREFIX + today + ".log";
        return new File(getLogFolderPath(), fileName);
    }
    
    /**
     * 记录用户操作日志
     * @param module 模块名称
     * @param operation 操作类型
     * @param message 日志消息
     */
    public static void logOperation(String module, String operation, String message) {
        String logMessage = String.format("[%s] %s: %s", module, operation, message);
        Log.i(TAG, logMessage);
    }
    
    /**
     * 记录设备操作日志
     * @param deviceName 设备名称
     * @param operation 操作类型
     * @param result 操作结果
     */
    public static void logDeviceOperation(String deviceName, String operation, String result) {
        logOperation("设备管理", operation, "设备:" + deviceName + ", 结果:" + result);
    }
    
    /**
     * 记录错误日志
     * @param module 模块名称
     * @param message 错误消息
     * @param e 异常对象，可为null
     */
    public static void logError(String module, String message, Exception e) {
        String logMessage = String.format("[%s] ERROR: %s", module, message);
        if (e != null) {
            Log.e(TAG, logMessage, e);
        } else {
            Log.e(TAG, logMessage);
        }
    }

    /**
     * 记录错误日志
     * @param module 模块名称
     * @param message 错误消息
     */
    public static void logError(String module, String message) {
        String logMessage = String.format("[%s] ERROR: %s", module, message);
        Log.e(TAG, logMessage);
    }
    
    /**
     * 将日志写入文件
     * @param message 日志消息
     */
    private static synchronized void writeToFile(String message) {
        BufferedWriter writer = null;
        
        try {
            File logFile = getLogFile();
            boolean fileExists = logFile.exists();
            
            // 创建父目录(如果不存在)
            if (!fileExists && !logFile.getParentFile().exists()) {
                boolean created = logFile.getParentFile().mkdirs();
                if (!created) {
                    Log.e(TAG, "创建日志目录失败: " + logFile.getParentFile().getAbsolutePath());
                    return;
                }
            }
            
            // 写入日志
            writer = new BufferedWriter(new FileWriter(logFile, true));
            writer.write(message);
            writer.newLine();
            writer.flush();
        } catch (IOException e) {
            Log.e(TAG, "写入日志文件失败", e);
        } finally {
            if (writer != null) {
                try {
                    writer.close();
                } catch (IOException e) {
                    Log.e(TAG, "关闭日志文件失败", e);
                }
            }
        }
    }
    
    /**
     * 获取所有日志文件列表
     * @return 日志文件数组
     */
    public static File[] getLogFiles() {
        File folder = new File(getLogFolderPath());
        if (folder.exists() && folder.isDirectory()) {
            return folder.listFiles((dir, name) -> name.startsWith(LOG_FILE_PREFIX) && name.endsWith(".log"));
        }
        return new File[0];
    }
    
    /**
     * 获取日志文件夹路径
     * @return 日志文件夹绝对路径
     */
    public static String getLogPath() {
        return getLogFolderPath();
    }
    
    /**
     * 记录调试日志
     * @param module 模块名称
     * @param message 调试消息
     */
    public static void logDebug(String module, String message) {
        String logMessage = String.format("[%s] DEBUG: %s", module, message);
        Log.d(TAG, logMessage);
    }
    
    /**
     * 清除所有日志文件
     * @return 是否成功
     */
    public static boolean clearAllLogs() {
        File folder = new File(getLogFolderPath());
        if (folder.exists() && folder.isDirectory()) {
            File[] files = folder.listFiles((dir, name) -> name.startsWith(LOG_FILE_PREFIX) && name.endsWith(".log"));
            if (files != null) {
                boolean allDeleted = true;
                for (File file : files) {
                    if (!file.delete()) {
                        allDeleted = false;
                        Log.e(TAG, "删除日志文件失败: " + file.getName());
                    }
                }
                return allDeleted;
            }
        }
        return false;
    }
} 